type Map[K comparable, V any] interface {
	Set(key K, val V)
	Get(key K) V
	TryGet(key K) (V, bool)
	AsNative() map[K]V
}

type CaseInsensitiveMap[V any] struct {
	lookUp map[string]string
	Native map[string]V
}

func (m *CaseInsensitiveMap[V]) getKey(key string) string {
	return strings.Map(func(r rune) rune {
		for {
			next := unicode.SimpleFold(r)
			if next <= r {
				return r
			}
			r = next
		}
	}, key)
}

func (m *CaseInsensitiveMap[V]) Set(key string, val V) {
	foldkey := m.getKey(key)
	if m.Native == nil {
		m.Native = map[string]V{}
	}
	if fk, ok := m.lookUp[foldkey]; ok {
		m.Native[fk] = val
	} else {
		if m.lookUp == nil {
			m.lookUp = map[string]string{}
		}
		m.lookUp[foldkey] = key
		m.Native[key] = val
	}
}

func (m *CaseInsensitiveMap[V]) Get(key string) V {
	v, _ := m.TryGet(key)
	return v
}

func (m *CaseInsensitiveMap[V]) TryGet(key string) (V, bool) {
	foldkey := m.getKey(key)
	if m.Native == nil {
		m.Native = map[string]V{}
	}
	if fk, ok := m.lookUp[foldkey]; ok {
		return m.Native[fk], true
	}
	return m.Native[key], false
}

func (m *CaseInsensitiveMap[V]) AsNative() map[string]V {
	return m.Native
}

type RegularMap[K comparable, V any] struct {
	Native map[K]V
}

func (m *RegularMap[K, V]) Set(key K, val V) {
	if m.Native == nil {
		m.Native = map[K]V{}
	}
	m.Native[key] = val
}

func (m *RegularMap[K, V]) Get(key K) V {
	return m.Native[key]
}

func (m *RegularMap[K, V]) TryGet(key K) (V, bool) {
	v, ok := m.Native[key]
	return v, ok
}

func (m *RegularMap[K, V]) AsNative() map[K]V {
	return m.Native
}